.data
instruction:	// [%fp+0]	// data_mem = 1
.word	0			
op:				// [%fp+1]	// 2
.word	0				
srcA:			// [%fp+2]	// 3
.word	0	
srcB:			// [%fp+3]	// 4
.word	0
dest:			// [%fp+4]	// 5
.word	0
pc:				// [%fp+5]	// 6
.word	0
mem:			// [%fp+6]	// 7
.word	0

.text
SuperGarbage:

///////////////////////////////////////////////////////////////////////////////
												// instruction count(IC), PC = IC - 1
	st		%l0, [%fp+5]						// 1
	st		%l1, [%fp+6]						// 2
	
///////////////////////////////////////////////////////////////////////////////

whileloop:

///////////////////////////////////////////////////////////////////////////////
	
	// arguments:
	
	// instruction->op		= %l1
	// instruction->srcA 	= %l2
	// instruction->srcB 	= %l3
	// instruction->dest	= %l4
	
///////////////////////////////////////////////////////////////////////////////

// struct inst *instruction = &(mem[pc]);

	// &(mem[pc])
	
	add		%l1, %l0, %tmp						// 3
			
	// instruction = &(mem[pc])
	st		%tmp, instruction					// 4

///////////////////////////////////////////////////////////////////////////////

// int op = instruction->op
	ld		[%tmp+0], %l1						// 5	
	st		%l1, op								// 6

///////////////////////////////////////////////////////////////////////////////

// int srcA = instruction->srcA;
	ld		[%tmp+1], %l2						// 7
	st		%l2, srcA							// 8

///////////////////////////////////////////////////////////////////////////////

// int srcB = instruction->srcB;
	ld		[%tmp+2], %l3						// 9		
	st		%l3, srcB							// 10

///////////////////////////////////////////////////////////////////////////////

// int dest = instruciton->dest;
	ld		[%tmp+3], %l4						// 11
	st		%l4, dest							// 12

///////////////////////////////////////////////////////////////////////////////

// pc = pc + 4
	add		%l0, 4, %l0							// 13
	st		%l0, [%fp+5]						// 14

///////////////////////////////////////////////////////////////////////////////

// switch(op)
	
	jmp		82									// 15

///////////////////////////////////////////////////////////////////////////////

case7:
	// return pc
	ld		[%fp+5], %rv						// 16
	
	ba 		whileloop 							// 17
	
///////////////////////////////////////////////////////////////////////////////

case6:
	mov		6, %tmp								// 18
	bne		%l1, %tmp, case7					// 19
	
	// mem[dest] = pc;
	ld		[%fp+6], %l0	// mem				// 20
	add		%l0, %l4, %l4	// &mem[dest]		// 21
	ld		[%fp+5], %tmp	// pc				// 22
	
	st		%tmp, [%l4]							// 23
	
	// if (mem[srcA] < 0)
	add		%l0, %l2, %l2	// &mem[srcA]		// 24
	ld		[%l2], %l2		// mem[srcA]		// 25
	
	mov	0, %tmp									// 26
	bge		%l1, %tmp, ifExit					// 27
	
	// pc = mem[srcB];		
	add		%l0, %l3, %l3	// &mem[srcB]		// 28
	ld		[%l3], %l3		// mem[srcB]		// 29
	st		%l3, [%fp+5]	// pc = mem[srcB]	// 30
	
ifExit:

	// break;
	ba 		whileloop							// 31

///////////////////////////////////////////////////////////////////////////////

case5:
	mov		5, %tmp								// 32
	bne		%l1, %tmp, case6					// 33
	
	// out mem[srcA], mem[srcB];
	ld		[%fp+6], %l0	// mem				// 34
	
	add		%l0, %l2, %l2	// &mem[srcA]		// 35
	ld		[%l2], %l2		// mem[srcA]		// 36
	add		%l0, %l3, %l3	// &mem[srcB]		// 37
	ld		[%l3], %l3		// mem[srcB]		// 38
	
	// out mem[srcA], mem[srcB]
	out		%l2, %l3							// 39
	
	// break;
	ba 		whileloop							// 40

///////////////////////////////////////////////////////////////////////////////

case4:
	mov		4, %tmp								// 41
	bne		%l1, %tmp, case5					// 42
	
	// in mem[dest], mem[srcA];
	ld		[%fp+6], %l0	// mem				// 43
	
	add		%l0, %l2, %l2	// &mem[srcA]		// 44
	ld		[%l2], %l2		// mem[srcA]		// 45
	add		%l0, %l4, %l4	// &mem[dest]		// 46
	ld		[%l4], %l4		// mem[dest]		// 47
	
	// in mem[dest], mem[srcA]
	in		%l4, %l2							// 48
	
	// break;
	ba 		whileloop							// 49

///////////////////////////////////////////////////////////////////////////////

case3:
	mov		3, %tmp								// 50
	bne		%l1, %tmp, case4					// 51
	
	ld		[%fp+6], %l0	// mem				// 52
	
	add		%l0, %l2, %l2	// &mem[srcA]		// 53
	ld		[%l2], %l2		// mem[srcA]		// 54
	add		%l0, %l2, %l2	// &mem[mem[srcA]]	// 55
	ld		[%l2], %l2		// mem[mem[srcA]]	// 56
	
	add		%l0, %l3, %l3	// &mem[srcB]		// 57
	ld		[%l3], %l3		// mem[srcB]		// 58
	
	add		%l0, %l4, %l4	// &mem[dest]		// 59
	
	swap	%l2, %l3, %l4						// 60
	
	// break;
	ba 		whileloop							// 61

///////////////////////////////////////////////////////////////////////////////

case2:
	mov		2, %tmp								// 62
	bne		%l1, %tmp, case3					// 63
	
	// mem[dest] = ~(mem[srcA] | mem[srcB]);
	ld		[%fp+6], %l0	// mem				// 64
	
	add		%l0, %l2, %l2	// &mem[srcA]		// 65
	ld		[%l2], %l2		// mem[srcA]		// 66
	
	add		%l0, %l3, %l3	// &mem[srcB]		// 67
	ld		[%l3], %l3		// mem[srcB]		// 68
	
	add		%l0, %l4, %l4	// &mem[dest]		// 69
	
	// (mem[srcA] | mem[srcB])
	or		%l2, %l3, %l3						// 70
	
	// ~(mem[srcA] | mem[srcB]), not operation
	xnor	%l3, 0, %l3							// 71
	
	// mem[dest] = ~(mem[srcA] | mem[srcB])
	st		%l3, [%l4]							// 72
	
	// break;
	ba 		whileloop							// 73

///////////////////////////////////////////////////////////////////////////////

case1:
	mov		1, %tmp								// 74
	bne		%l1, %tmp, case2					// 75
	
	// mem[dest] = mem[srcA] >> 1;	
	ld		[%fp+6], %l0	// mem				// 76
	add		%l0, %l2, %l2	// &mem[srcA]		// 77
	ld		[%l2], %l2		// mem[srcA]		// 78
	
	add		%l0, %l4, %l4	// &mem[dest]		// 79
		
	srl		%l2, 1, %l2		// mem[srcA] >> 1	// 80
	
	// mem[dest] = mem[srcA] >> 1
	st		%l2, [%l4]							// 81
	
	// break;
	ba 		whileloop							// 82

///////////////////////////////////////////////////////////////////////////////

case0:
	mov		0, %tmp								// 83
	bne		%l1, %tmp, case1					// 84

	// mem[dest] = mem[srcA] - mem[srcB]; 		
	ld		[%fp+6], %l0	// mem				// 85
	
	add		%l0, %l2, %l2	// &mem[srcA]		// 86
	ld		[%l2], %l2		// mem[srcA]		// 87
	
	add		%l0, %l3, %l3	// &mem[srcB]		// 88
	ld		[%l3], %l3		// mem[srcB]		// 89
	
	// mem[srcA] - mem[srcB]
	sub		%l2, %l3, %l3						// 90
	
	add		%l0, %l4, %l4	// &mem[dest]		// 91
	
	// mem[dest] = mem[srcA] - mem[srcB]		
	st		%l3, [%l4]							// 92
	
	// break;
	ba 		whileloop							// 93

///////////////////////////////////////////////////////////////////////////////



	
	
	
	
	



	
